import moment from 'moment'
import { isDataType } from '@/utils/tools'

// 验证是否是数字或字符串
function validateToNumber(val) {
  return typeof val === 'string' || typeof val === 'number'
}

// 验证日期是否合理
function validateDate(val) {
  let date = val
  // Invalid Date
  if (!date || !date.getTime()) {
    return ''
  }
  let day = moment(date).format('YYYY-MM-DD')
  if (day === '1970-01-01' || day === '1900-01-01') {
    return false
  }
  return true
}

// 格式化日期+时间
export function formatDateTime(date) {
  let temp = date
  if (!isDataType(date, 'Date')) {
    temp = new Date(date)
  }
  if (!validateDate(temp)) {
    return ''
  }
  return moment(date).format('YYYY-MM-DD HH:mm:ss')
}

// 格式化日期+时间 ，去掉T
export function formatDateTimeT(date) {
  if (!date) {
    return date
  }
  return date.replace('T', ' ')
}

// 格式化日期为YYYY-MM-DD
export function formatDate(date) {
  let temp = date
  if (!isDataType(date, 'Date')) {
    temp = new Date(date)
  }
  if (!validateDate(temp)) {
    return ''
  }
  return moment(date).format('YYYY-MM-DD')
}

/**
 * 格式化日期YYYYMMDD为YYYY-MM-DD
 * @param {
 *   dateString: YYYYMMDD
 * }
 * @returns
 */
export function formateStringDate(dateString) {
  return dateString.replace(/^(\d{4})(\d{2})(\d{2})$/, '$1-$2-$3')
}

// 格式化日期为YYYY-MM
export function formatMonth(date) {
  let temp = date
  if (!isDataType(date, 'Date')) {
    temp = new Date(date)
  }
  if (!validateDate(temp)) {
    return ''
  }
  return moment(date).format('YYYY-MM')
}

/**
 * 格式化日期YYYY-MM-DD为YYYYMMDD
 * @param {
 *   date: YYYY-MM-DD
 * } obj
 * @returns
 */
export function formateDateToString(date) {
  if (!date) {
    return null
  }
  const noramlDate = new Date(date)
  const year = noramlDate.getFullYear()
  const curMonth = noramlDate.getMonth() + 1
  const month = curMonth >= 10 ? '' + curMonth : '0' + curMonth
  const day = noramlDate.getDate() >= 10 ? '' + noramlDate.getDate() : '0' + noramlDate.getDate()
  const todayStr = year + month + day
  return todayStr
}

// 转换当前时间为时间戳
export function dateChange() {
  let date = Date.parse(new Date())
  return date
}

// 格式化默认起始时间
export function formatDefaultTime(val) {
  if (!val || val === '1900-01-01 00:00:00') return ''
  return val
}

/**
 * 计算某个时间，X小时X分钟X秒后的时间
 * @dateTime 日期时间
 * @hours 小时
 * @minutes 小时
 * @seconds 小时
 * @returns datetime
 */
export function formateDateTimeToAfter(dateTime, hours = 0, minutes = 0, seconds = 0) {
  // let allSeconds = Date.parse(new Date(dateTime))  + formateSeconds(hours, minutes, seconds)
  // let afterDateTime =
  // return afterDateTime
  if (!dateTime) {
    return dateTime
  }
  let curTime = new Date(dateTime)
  // 在时间上加上小时
  let addHour = curTime.setHours(curTime.getHours() + hours)
  curTime = new Date(addHour)
  // 在时间上加上分钟
  let addMinute = new Date(curTime.setMinutes(curTime.getMinutes() + minutes))
  curTime = new Date(addMinute)
  // 在时间上加上秒
  let addSeconds = new Date(curTime.setSeconds(curTime.getSeconds() + seconds))
  curTime = formatDateTime(new Date(addSeconds))
  return curTime
}

/**
 * 将单独的时分秒拼接为 hh:mm:ss
 * @hours 时
 * @minutes 分
 * @seconds 秒
 * @return hh:mm:ss
 */
export function formateHoursMinutesSeconds(hours, minutes, seconds) {
  let timeDiff = zero(hours) + ':' + zero(minutes) + ':' + zero(seconds)
  // 数字补零
  function zero(num) {
    if (num && !isNaN(num)) {
      return num < 10 ? '0' + num : num
    } else {
      return '00'
    }
  }
  return timeDiff
}

/**
 * 格式化 时, 分, 秒 为 毫秒
 * @hours 时
 * @minutes 分
 * @seconds 秒
 * @returns millisecond
 */
export function formateSeconds(hours, minutes, seconds) {
  let millisecond = 0
  if (hours && !isNaN(hours)) {
    millisecond = millisecond + hours * (1000 * 60 * 60)
  }
  if (minutes && !isNaN(minutes)) {
    millisecond = millisecond + minutes * (1000 * 60)
  }
  if (seconds && !isNaN(seconds)) {
    millisecond = millisecond + seconds * 1000
  }
  return millisecond
}

// 格式化金额
export function formatMoney(money) {
  if (!validateToNumber(money)) {
    return ''
  }
  let num = parseFloat(money)
  if (num === 0) {
    return 0
  }
  if (!num) {
    return ''
  }
  let mark = num.toString().split('.')[1]
  if (!mark) {
    return (num / 100).toFixed(2)
  }
  if (mark.length === 1) {
    return (num / 100).toFixed(3)
  }
  return (num / 100).toFixed(4)
}

// 格式化金额(格式化总价时展示用)
export function formatMoneyForSumShow(money) {
  if (!validateToNumber(money)) {
    return ''
  }
  let num = parseFloat(money)
  if (num === 0) {
    return 0
  }
  if (!num) {
    return ''
  }
  return (num / 100).toFixed(2)
}

// 格式化金额，带符号
export function formatMoneyWithSymbol(money) {
  if (!validateToNumber(money)) {
    return ''
  }
  let num = parseFloat(money)
  if (num === 0) {
    return '￥0'
  }
  if (!num) {
    return ''
  }
  return '￥' + (num / 100).toFixed(2)
}

// 格式化时长
export function formatDuration(time) {
  if (!validateToNumber(time)) {
    return ''
  }
  let durition = parseFloat(time)
  if (!durition && durition !== 0) {
    return ''
  }
  if (durition < 0) {
    return ''
  }
  let m = ~~(durition / 60)
  let s = durition % 60
  if (m < 60 && s === 0) {
    return `${m}分钟`
  }
  let h = ~~(m / 60)
  m = m % 60
  let d = ~~(h / 24)
  h = h % 24
  let retS = s ? `${s}秒` : ''
  let retM = m ? `${m}分` : ''
  let retH = h ? `${h}小时` : ''
  let retD = d ? `${d}天` : ''
  return `${retD}${retH}${retM}${retS}`
}

const SEX_LIST = ['', '男', '女']
// 格式化性别
export function formatSex(sex) {
  return SEX_LIST[sex] || ''
}

// 格式化年龄
export function formatAge(age) {
  if (!age) return ''
  // 纯数字
  if (/^\d+$/.test(age)) return `${age}岁`
  return age
}

// 格式化年龄
export function formatMobileHidden(mobile) {
  if (!mobile) return ''
  var reg = /^(\d{3})\d{4}(\d{4})$/
  return mobile.replace(reg, '$1****$2')
}

// 升序排序
export function objKeySort(obj) {
  if (!obj || Array.isArray(obj)) {
    return ''
  }
  // 升序
  let newkey = Object.keys(obj).sort() // 先用Object内置类的keys方法获取要排序对象的属性名，再利用Array原型上的sort方法对获取的属性名进行排序，newkey是一个数组
  // 倒序
  // var newkey = Object.keys(obj).sort().reverse();
  let newObj = {} // 创建一个新的对象，用于存放排好序的键值对
  for (let i = 0; i < newkey.length; i++) {
    // 遍历newkey数组
    newObj[newkey[i]] = obj[newkey[i]] // 向新创建的对象中按照排好的顺序依次增加键值对
  }
  let objValuesString = ''
  Object.values(newObj).forEach(item => {
    if (!Array.isArray(item) && !(item instanceof Object)) {
      objValuesString = objValuesString + item
    }
  })
  return objValuesString // 返回排好序的新对象的值拼接起来的字符窜
}

/**
 * 格式化数字,千位分隔符
 * s：数字
 * n：格式小位数【默认0位小数】
 */
export function formatNumberToDollar(s, n) {
  if (!s) {
    return s
  }
  if (n) {
    n = n > 0 && n <= 20 ? n : 2
  } else {
    n = 0
  }
  // eslint-disable-next-line no-useless-escape
  s = parseFloat((s + '').replace(/[^\d\.-]/g, '')).toFixed(n) + ''
  let l = s.split('.')[0].split('').reverse()
  let r = s.split('.')[1]
  let t = ''
  for (let i = 0; i < l.length; i++) {
    t += l[i] + ((i + 1) % 3 === 0 && i + 1 !== l.length ? ',' : '')
  }
  return t.split('').reverse().join('') + (r ? '.' + r : '')
}

/**
 * 请求地址拼接指定参数：/url/{id}
 * @formatePathParams {Object} 路径参数
 * @return 新path
 */
export function formatePathParams(path, formatePathParams) {
  if (path.includes('{') && formatePathParams) {
    let keys = Object.keys(formatePathParams)
    keys.forEach(it => {
      path = path.replace('{' + `${it}` + '}', formatePathParams[it])
    })
  }
  return path
}

/**
 * 请求地址拼接路径的参数： /url?id=xx&name=yy
 * @formatePathParams {Object} 路径参数
 * @return 新path
 */
export function formateUrlParams(path, urlParams) {
  let paramsNum = 0
  for (let key in urlParams) {
    // 如果urlParams不为空，并且是第一个不为空的参数时，直接进行拼接，不用加&
    paramsNum++
    if (paramsNum === 1) {
      path = path + '?' + key + '=' + urlParams[key]
    } else if (paramsNum > 1) {
      path = path + '&' + key + '=' + urlParams[key]
    }
  }
  return path
}

/**
 * 过滤选项的编号
 * @index {Number} 下标
 * @return {String} 字母
 */
export function formatQuestionIndex(index) {
  if (index === undefined || index === null) {
    return ''
  }
  return String.fromCharCode(index + 65)
}

/**
 * 转换字母为数字
 * @letterString {String} 字符窜-字母
 * @returns {Array} 下标数组
 */
export function formatQuestionLetter(letterString) {
  let indexs = []
  for (let i = 0; i < letterString.length; ++i) {
    let letter = letterString.charCodeAt(i) - 65
    indexs.push(letter)
  }
  return indexs
}
